package com.fjl.enumtest;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;

/**
 * <p>
 * 枚举抽象类。
 * </p>
 * 
 * 定义枚举类型数据操作时所需要用到的方法，如枚举名与值互相获取等。
 * 
 */
public  class Enumeration
{

	protected Enumeration(int i)
	{
		m_value = i;
	}
	

	/**
	 * 根据指定枚举对象取枚举值。
	 * 
	 * @param enum1 枚举对象
	 * @return 返回枚举值
	 */
	public static final int getValue(Enumeration enum1)
	{
		return enum1.value();
	}

	/**
	 * 根据枚举值解析枚举对象。
	 * 
	 * 该方法根据枚举值解析枚举对象。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @param iVal 枚举值
	 * @return 返回解析的枚举对象
	 */
	public static final Enumeration parse(Class<? extends Enumeration> extendClass, int iVal)
	{
		if (extendClass == null)
			return null;
		ArrayList<Integer> valueList = new ArrayList<Integer>();
		ArrayList<Enumeration> enumList = new ArrayList<Enumeration>();
		getEnumNameValueAndEntry(extendClass, null, valueList, enumList);
		Integer integer = Integer.valueOf(iVal);
		if (!valueList.contains(integer))
		{
			throw new RuntimeException("==");
		}
		else
		{
			int j = valueList.indexOf(integer);
			return (Enumeration) enumList.get(j);
		}
	}// end parseValue()

	/**
	 * 根据枚举名称解析枚举对象。
	 * 
	 * 该方法根据枚举名称解析枚举对象。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @param sName 枚举名称
	 * @return 返回解析的枚举对象
	 */
	public static final Enumeration parse(Class<? extends Enumeration> extendClass, String sName)
	{
		if (extendClass == null || sName == null)
			return null;
		ArrayList<String> nameList = new ArrayList<String>();
		ArrayList<Enumeration> enumList = new ArrayList<Enumeration>();
		getEnumNameValueAndEntry(extendClass, nameList, null, enumList);
		if (!nameList.contains(sName))
		{
			throw new RuntimeException("==");
		}
		else
		{
			int i = nameList.indexOf(sName);
			return (Enumeration) enumList.get(i);
		}
	}// end parse()

	/**
	 * 取枚举名称字符串数组。
	 * 
	 * 该方法取派生类的枚举名称字符串数组。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @return 返回枚举名称字符串数组
	 */
	public static final String[] getNames(Class<? extends Enumeration> extendClass)
	{
		if (extendClass == null)
			return new String[0];
		if (!isValidEnumClass(extendClass))
		{
			return new String[0];
		}
		else
		{
			ArrayList<String> nameList = new ArrayList<String>();
			getEnumNameValueAndEntry(extendClass, nameList, null, null);
			String as[] = new String[nameList.size()];
			nameList.toArray(as);
			return as;
		}
	}// end getNames()

	/**
	 * 取枚举数值数组。
	 * 
	 * 该方法取派生类的枚举名称字符串数组。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @return 返回枚举数值数组
	 */
	public static int[] getValues(Class<? extends Enumeration> extendClass)
	{
		if (extendClass == null)
			return new int[0];
		if (!isValidEnumClass(extendClass))
			return new int[0];
		ArrayList<Integer> valueList = new ArrayList<Integer>();
		getEnumNameValueAndEntry(extendClass, null, valueList, null);
		int ai[] = new int[valueList.size()];
		for (int i = 0; i < valueList.size(); i++)
			ai[i] = Integer.parseInt(valueList.get(i).toString());

		return ai;
	}// end getValues()

	/**
	 * 取枚举列表。
	 * 
	 * 该方法取派生类的枚举列表。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @return 返回枚举列表数组
	 */
	public static Enumeration[] getEnums(Class<? extends Enumeration> extendClass)
	{
		if (extendClass == null)
			return new Enumeration[0];
		if (!isValidEnumClass(extendClass))
		{
			return new Enumeration[0];
		}
		else
		{
			ArrayList<Enumeration> enumList = new ArrayList<Enumeration>();
			getEnumNameValueAndEntry(extendClass, null, null, enumList);
			Enumeration aenum[] = new Enumeration[enumList.size()];
			enumList.toArray(aenum);
			return aenum;
		}
	}// end getEnums()

	/**
	 * 根据枚举值取名称。
	 * 
	 * 该方法根据枚举值取派生类的枚举名称。
	 * 
	 * @param class1 该枚举类的派生类
	 * @param iVal 枚举值
	 * @return 返回枚举名称
	 */
	public static String getNameByValue(Class<? extends Enumeration> class1, int iVal)
	{
		ArrayList<String> nameList = new ArrayList<String>();
		ArrayList<Integer> valueList = new ArrayList<Integer>();
		getEnumNameValueAndEntry(class1, nameList, valueList, null);
		Integer integer = Integer.valueOf(iVal);
		if (!valueList.contains(integer))
		{
			throw new RuntimeException("==");
		}
		else
		{
			int j = valueList.indexOf(integer);
			return (String) nameList.get(j);
		}
	}// end getNameByValue()

	/**
	 * 根据枚举名称取枚举值。
	 * 
	 * 该方法根据枚举名称取派生类的枚举值。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @param sName 枚举名称
	 * @return 返回枚举值
	 */
	public static int getValueByName(Class<? extends Enumeration> extendClass, String sName)
	{
		ArrayList<String> nameList = new ArrayList<String>();
		ArrayList<Integer> valueList = new ArrayList<Integer>();
		getEnumNameValueAndEntry(extendClass, nameList, valueList, null);
		if (!nameList.contains(sName))
		{
			throw new RuntimeException("==");
		}
		else
		{
			int i = nameList.indexOf(sName);
			return Integer.parseInt(valueList.get(i).toString());
		}
	}// end getValueByName()

	/**
	 * 检查指定枚举值在派生类中是否已定义。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @param iVal 枚举值
	 * @return 已定义返回true
	 */
	public static boolean isDefined(Class<? extends Enumeration> extendClass, int iVal)
	{
		ArrayList<Integer> valueList = new ArrayList<Integer>();
		getEnumNameValueAndEntry(extendClass, null, valueList, null);
		Integer integer = Integer.valueOf(iVal);
		return valueList.contains(integer);
	}

	/**
	 * 检查指定枚举名称在派生类中是否已定义。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @param sName 枚举名称
	 * @return 已定义返回true
	 */
	public static boolean isDefined(Class<? extends Enumeration> extendClass, String sName)
	{
		ArrayList<String> nameList = new ArrayList<String>();
		getEnumNameValueAndEntry(extendClass, nameList, null, null);
		return nameList.contains(sName);
	}

	/**
	 * 检查派生类是否合法。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @return 合法返回true
	 */
	private static boolean isValidEnumClass(Class<? extends Enumeration> extendClass)
	{
		if (extendClass == null)
			return false;
		return extendClass.getSuperclass().equals(Enumeration.class);
	}

	/**
	 * 取枚举派生类的枚举名称、枚举值以及枚举对象。
	 * 
	 * 该方法取取枚举派生类的枚举名称、枚举值以及枚举对象。
	 * 
	 * @param extendClass 该枚举类的派生类
	 * @param nameList 枚举名称列表
	 * @param valueList 枚举值列表
	 * @param enumList 枚举对象列表
	 */
	private static void getEnumNameValueAndEntry(Class<? extends Enumeration> extendClass, ArrayList<String> nameList, ArrayList<Integer> valueList,
			ArrayList<Enumeration> enumList)
	{
		if (extendClass == null)
			return;
		if (nameList == null && valueList == null && enumList == null)
			return;
		Field afield[] = extendClass.getFields();
		if (afield == null || afield.length == 0)
			return;
		int i = afield.length;
		for (int j = 0; j < i; j++)
		{
			Field field = afield[j];
			if (!isValidEnumField(field))
				continue;
			Enumeration enum1;
			enum1 = null;
			try
			{
				enum1 = (Enumeration) field.get(null);
			}
			catch (IllegalAccessException illegalaccessexception)
			{
				continue;
			}
			catch (IllegalArgumentException illegalargumentexception)
			{
				continue;
			}
			if (enum1 == null)
				continue;
			if (nameList != null)
				nameList.add(field.getName());
			if (valueList != null)
			{
				Integer integer = Integer.valueOf(enum1.value());
				valueList.add(integer);
			}
			if (enumList != null)
				enumList.add(enum1);
		}
	}// end getEnumNameValueAndEntry()

	/**
	 * 检查字段是否合法，合法返回true
	 */
	private static final boolean isValidEnumField(Field field)
	{
		if (field == null)
			return false;
		Class<?> class1 = field.getDeclaringClass();
		if (!field.getType().equals(class1))
			return false;
		int i = field.getModifiers();
		return Modifier.isPublic(i) && Modifier.isStatic(i) && Modifier.isFinal(i);
	}

	/**
	 * 取当前对象枚举字符串。
	 */
	public final String name()
	{
		return getNameByValue(getClass(), value());
	}

	/**
	 * 取当前对象枚举值。
	 */
	public final int value()
	{
		return m_value;
	}

	/**
	 * 比较指定对象是否等于当前枚举常量。
	 * 
	 * @param obj 枚举对象
	 * @return 如果指定对象等于此枚举常量，则返回 true。
	 */
	public final boolean equals(Object obj)
	{
		if (obj == null)
			return false;
		if (!getClass().equals(obj.getClass()))
			return false;
		Enumeration enum1;
		enum1 = (Enumeration) obj;
		return value() == enum1.value();
	}

	/**
	 * 重写hashCode()返回对象的哈希码值。
	 */
	public final int hashCode()
	{
		return System.identityHashCode(this);
	}

	private final int m_value;
}
